// 导入台球杆数据集
const cueData = require('../../miniprogram/data/qg.js')

Page({
  // 页面数据定义
  data: {
    allCues: [],          // 所有球杆数据
    filteredCues: [],    // 筛选后的球杆数据
    displayedCues: [],    // 当前显示的数据（分页/随机）
    usedCueIds: [],       // 已展示过的球杆ID（防重复）
    
    // 筛选相关配置
    priceOptions: ['全部', '200-1000元', '1000-2000元', '2000-3000元', '3000元以上'], // 价格区间选项
    priceIndex: 0,        // 当前选择的价格区间索引
    brandOptions: ['全部'], // 品牌筛选选项（动态加载）
    brandIndex: 0,        // 当前选择的品牌索引
    ratingOptions: ['全部', '4星以上', '3星以上', '2星以上'], // 评分筛选选项
    ratingIndex: 0,       // 当前选择的评分索引
    
    // 界面状态
    activeTab: 1,         // 当前激活的标签页
    searchKeyword: '',    // 搜索关键词
    refreshing: false,    // 下拉刷新状态
    loadingMore: false,   // 加载更多状态
    showBackTop: false,   // 显示返回顶部按钮
    pageSize: 8,          // 每页显示数量
    currentPage: 1        // 当前页码
  },

  // 页面加载生命周期
  onLoad() {
    this.initData()  // 初始化数据
  },

  // 数据初始化方法
  initData() {
    this.loadCues(() => {  // 加载基础数据
      this.setData({
        displayedCues: this.getRandomCues(this.data.pageSize) // 初始化显示随机数据
      }, () => {
        wx.stopPullDownRefresh()  // 停止下拉刷新动画
      })
    })
  },

  // 数据加载方法（带回调）
  loadCues(callback) {
    const brands = [...new Set(cueData.cues.map(item => item.brand))] // 提取唯一品牌
    this.setData({
      allCues: cueData.cues,        // 存储所有数据
      filteredCues: cueData.cues,   // 初始化筛选数据为全部
      brandOptions: ['全部', ...brands] // 构建品牌筛选选项
    }, callback)  // 回调函数传递
  },

  // 随机获取球杆方法（防重复机制）
  getRandomCues(count) {
    const { allCues, usedCueIds } = this.data
    
    // 空数据保护
    if (!allCues || allCues.length === 0) return []

    const availableCues = allCues.filter(cue => !usedCueIds.includes(cue.id)) // 过滤已展示
    
    // 重置机制：当可用数据不足时清空历史记录
    if (availableCues.length < count) {
      this.setData({ usedCueIds: [] })
      return this.getRandomCues(count) // 递归调用
    }
    
    // 随机选择逻辑
    const randomCount = Math.min(count, availableCues.length)
    const randomCues = []
    const newUsedIds = [...usedCueIds]  // 创建新数组避免直接修改
    
    for (let i = 0; i < randomCount; i++) {
      const randomIndex = Math.floor(Math.random() * availableCues.length)
      const selectedCue = availableCues[randomIndex]
      
      // 防重复检查
      if (!newUsedIds.includes(selectedCue.id)) {
        randomCues.push(selectedCue)
        newUsedIds.push(selectedCue.id)  // 记录已选ID
        availableCues.splice(randomIndex, 1) // 移除已选项
      }
    }
    
    this.setData({ usedCueIds: newUsedIds })  // 更新已用ID
    return randomCues
  },

  // 下拉刷新处理
  onRefresh() {
    this.setData({ refreshing: true })
    
    // 判断筛选状态
    if (this.data.filteredCues.length < this.data.allCues.length) {
      // 筛选状态：重置分页
      this.setData({
        displayedCues: this.data.filteredCues.slice(0, this.data.pageSize),
        usedCueIds: this.data.filteredCues.slice(0, this.data.pageSize).map(cue => cue.id),
        currentPage: 1,
        refreshing: false
      })
    } else {
      // 普通状态：随机刷新
      this.setData({ usedCueIds: [], displayedCues: [] }, () => {
        const randomCues = this.getRandomCues(this.data.pageSize)
        this.setData({ displayedCues: randomCues, refreshing: false })
      })
    }
  },

  // 上拉加载更多（分页处理）
  onReachBottom() {
    if (this.data.loadingMore) return  // 防止重复加载
    
    this.setData({ loadingMore: true })
    
    setTimeout(() => {  // 模拟网络延迟
      const { filteredCues, allCues, displayedCues, pageSize } = this.data
      const isFiltered = filteredCues.length < allCues.length  // 筛选状态判断
      
      if (isFiltered) {
        // 筛选状态分页加载
        const nextPage = this.data.currentPage + 1
        const newDisplay = filteredCues.slice(0, pageSize * nextPage)
        
        if (newDisplay.length === displayedCues.length) {  // 无更多数据
          wx.showToast({ title: '只有这些了~', icon: 'none' })
        } else {
          this.setData({
            displayedCues: newDisplay,
            currentPage: nextPage,
            usedCueIds: newDisplay.map(cue => cue.id)
          })
        }
      } else {
        // 随机加载更多
        const randomCues = this.getRandomCues(pageSize)
        this.setData({ displayedCues: [...displayedCues, ...randomCues] })
      }

      this.setData({ loadingMore: false })
    }, 800)  // 800ms延迟模拟网络请求
  },

  // 滚动事件处理
  onPageScroll(e) {
    this.setData({ showBackTop: e.scrollTop > 300 })  // 显示返回顶部按钮
  },

  // 返回顶部功能
  scrollToTop() {
    wx.pageScrollTo({ scrollTop: 0, duration: 300 })  // 300ms滚动动画
  },

  // 搜索输入处理
  onSearch(e) {
    this.setData({ searchKeyword: e.detail.value.trim() }, this.applyFilters)
  },

  // 筛选条件变更处理
  changePrice(e) { this.setData({ priceIndex: e.detail.value }, this.applyFilters) },
  changeBrand(e) { this.setData({ brandIndex: e.detail.value }, this.applyFilters) },
  changeRating(e) { this.setData({ ratingIndex: e.detail.value }, this.applyFilters) },

  // 综合筛选逻辑
  applyFilters() {
    let result = [...this.data.allCues]
    const { priceIndex, brandIndex, ratingIndex, searchKeyword } = this.data

    // 价格筛选（范围匹配）
    if (priceIndex > 0) {
      const priceRanges = [ [200,1e3], [1e3,2e3], [2e3,3e3], [3e3,Infinity] ]
      const [min, max] = priceRanges[priceIndex - 1]
      result = result.filter(item => {
        const price = Number(item.price) || 0
        return price >= min && price <= max
      })
    }

    // 品牌筛选（精确匹配）
    if (brandIndex > 0) {
      const selectedBrand = this.data.brandOptions[brandIndex]
      result = result.filter(item => item.brand === selectedBrand)
    }

    // 评分筛选（最小值匹配）
    if (ratingIndex > 0) {
      const minRatings = [0, 4, 3, 2]
      result = result.filter(item => item.rating >= minRatings[ratingIndex])
    }

    // 关键词搜索（模糊匹配）
    if (searchKeyword) {
      const kw = searchKeyword.toLowerCase()
      result = result.filter(item => 
        item.name.toLowerCase().includes(kw) || 
        (item.brand && item.brand.toLowerCase().includes(kw))
      )
    }

    // 更新数据状态
    this.setData({ 
      filteredCues: result,
      displayedCues: result.slice(0, this.data.pageSize),
      usedCueIds: result.slice(0, this.data.pageSize).map(cue => cue.id),
      currentPage: 1
    })
  },

  // 查看商品详情
  viewDetail(e) {
    const id = e.currentTarget.dataset.id  // 获取商品ID
    wx.navigateTo({ url: `/pages/gouwu/gouwu?id=${id}` })  // 跳转详情页
  },

  // 缓存优化相关
  cache: {  // 缓存对象
    filteredData: null,      // 缓存筛选结果
    lastFilterParams: null   // 上次筛选参数
  },

  // 智能刷新方法
  async onRefresh() {
    const startTime = Date.now()
    this.setData({ refreshing: true })
    
    // 缓存命中判断
    this.shouldUseCache() ? this.applyCachedData() : await this.processNewData()
    
    await new Promise(resolve => wx.nextTick(resolve))  // 等待渲染完成
    this.setData({ refreshing: false })
    console.log(`刷新耗时：${Date.now() - startTime}ms`)  // 性能监控
  },

  // 缓存有效性判断
  shouldUseCache() {
    const currentParams = JSON.stringify({  // 序列化当前参数
      priceIndex: this.data.priceIndex,
      brandIndex: this.data.brandIndex,
      ratingIndex: this.data.ratingIndex,
      searchKeyword: this.data.searchKeyword
    })
    return currentParams === this.cache.lastFilterParams  // 参数比对
  },

  // 应用缓存数据
  applyCachedData() {
    this.setData({
      displayedCues: this.cache.filteredData.slice(0, this.data.pageSize),
      usedCueIds: [],
      currentPage: 1
    })
  },

  // 处理新数据（洗牌算法优化）
  async processNewData() {
    const shuffle = array => {  // Fisher-Yates洗牌算法
      for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]]
      }
      return array
    }

    const newData = shuffle([...this.data.allCues])  // 创建随机副本
    this.cache = {  // 更新缓存
      filteredData: newData,
      lastFilterParams: JSON.stringify({  // 存储当前参数快照
        priceIndex: this.data.priceIndex,
        brandIndex: this.data.brandIndex,
        ratingIndex: this.data.ratingIndex,
        searchKeyword: this.data.searchKeyword
      })
    }
    this.setData({  // 更新显示数据
      displayedCues: newData.slice(0, this.data.pageSize),
      usedCueIds: [],
      currentPage: 1
    })
  }
})